home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / java / jni.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  63KB  |  1,811 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Java Runtime Interface.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation and Sun Microsystems, Inc.
  18.  * Portions created by the Initial Developer are Copyright (C) 1993-1996
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the MPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the MPL, the GPL or the LGPL.
  34.  *
  35.  * ***** END LICENSE BLOCK ***** */
  36.  
  37. #ifndef JNI_H
  38. #define JNI_H
  39.  
  40. #include <stdio.h>
  41. #include <stdarg.h>
  42.  
  43. /* jni_md.h contains the machine-dependent typedefs for jbyte, jint 
  44.    and jlong */ 
  45.  
  46. #include "jni_md.h"
  47.  
  48. #ifdef __cplusplus
  49. extern "C" {
  50. #endif
  51.  
  52. /*
  53.  * JNI Types
  54.  */
  55.  
  56. typedef unsigned char    jboolean;
  57. typedef unsigned short    jchar;
  58. typedef short        jshort;
  59. typedef float        jfloat;
  60. typedef double        jdouble;
  61.  
  62. typedef jint            jsize;
  63.  
  64. #ifdef __cplusplus
  65.  
  66. class _jobject {};
  67. class _jclass : public _jobject {};
  68. class _jthrowable : public _jobject {};
  69. class _jstring : public _jobject {};
  70. class _jarray : public _jobject {};
  71. class _jbooleanArray : public _jarray {};
  72. class _jbyteArray : public _jarray {};
  73. class _jcharArray : public _jarray {};
  74. class _jshortArray : public _jarray {};
  75. class _jintArray : public _jarray {};
  76. class _jlongArray : public _jarray {};
  77. class _jfloatArray : public _jarray {};
  78. class _jdoubleArray : public _jarray {};
  79. class _jobjectArray : public _jarray {};
  80.  
  81. typedef _jobject *jobject;
  82. typedef _jclass *jclass;
  83. typedef _jthrowable *jthrowable;
  84. typedef _jstring *jstring;
  85. typedef _jarray *jarray;
  86. typedef _jbooleanArray *jbooleanArray;
  87. typedef _jbyteArray *jbyteArray;
  88. typedef _jcharArray *jcharArray;
  89. typedef _jshortArray *jshortArray;
  90. typedef _jintArray *jintArray;
  91. typedef _jlongArray *jlongArray;
  92. typedef _jfloatArray *jfloatArray;
  93. typedef _jdoubleArray *jdoubleArray;
  94. typedef _jobjectArray *jobjectArray;
  95.  
  96. #else
  97.  
  98. struct _jobject;
  99.  
  100. typedef struct _jobject *jobject;
  101. typedef jobject jclass;
  102. typedef jobject jthrowable;
  103. typedef jobject jstring;
  104. typedef jobject jarray;
  105. typedef jarray jbooleanArray;
  106. typedef jarray jbyteArray;
  107. typedef jarray jcharArray;
  108. typedef jarray jshortArray;
  109. typedef jarray jintArray;
  110. typedef jarray jlongArray;
  111. typedef jarray jfloatArray;
  112. typedef jarray jdoubleArray;
  113. typedef jarray jobjectArray;
  114.  
  115. #endif
  116.  
  117. #if 0    /* moved to jri_md.h */
  118. typedef jobject jref; /* For transition---not meant to be part of public 
  119.              API anymore.*/
  120. #endif
  121.  
  122. typedef union jvalue {
  123.     jboolean z;
  124.     jbyte    b;
  125.     jchar    c;
  126.     jshort   s;
  127.     jint     i;
  128.     jlong    j;
  129.     jfloat   f;
  130.     jdouble  d;
  131.     jobject  l;
  132. } jvalue;
  133.  
  134. struct _jfieldID;
  135. typedef struct _jfieldID *jfieldID;
  136.  
  137. struct _jmethodID;
  138. typedef struct _jmethodID *jmethodID;
  139.  
  140. /*
  141.  * jboolean constants
  142.  */
  143.  
  144. #define JNI_FALSE 0
  145. #define JNI_TRUE 1
  146.  
  147. /*
  148.  * possible return values for JNI functions.
  149.  */
  150.  
  151. #define JNI_OK 0
  152. #define JNI_ERR (-1)
  153.  
  154. /*
  155.  * used in ReleaseScalarArrayElements
  156.  */
  157.   
  158. #define JNI_COMMIT 1
  159. #define JNI_ABORT 2
  160.  
  161. /*
  162.  * used in RegisterNatives to describe native method name, signature,
  163.  * and function pointer.
  164.  */
  165.  
  166. typedef struct {
  167.     char *name;
  168.     char *signature;
  169.     void *fnPtr;
  170. } JNINativeMethod;
  171.  
  172. /*
  173.  * JNI Native Method Interface.
  174.  */
  175.  
  176. struct JNINativeInterface_;
  177.  
  178. struct JNIEnv_;
  179.  
  180. #ifdef __cplusplus
  181. typedef JNIEnv_ JNIEnv;
  182. #else
  183. typedef const struct JNINativeInterface_ *JNIEnv;
  184. #endif
  185.  
  186. /*
  187.  * JNI Invocation Interface.
  188.  */
  189.  
  190. struct JNIInvokeInterface_;
  191.  
  192. struct JavaVM_;
  193.  
  194. #ifdef __cplusplus
  195. typedef JavaVM_ JavaVM;
  196. #else
  197. typedef const struct JNIInvokeInterface_ *JavaVM;
  198. #endif
  199.  
  200. struct JNINativeInterface_ {
  201.     void *reserved0;
  202.     void *reserved1;
  203.     void *reserved2;
  204.  
  205.     void *reserved3;
  206.     jint (JNICALL *GetVersion)(JNIEnv *env);
  207.  
  208.     jclass (JNICALL *DefineClass)
  209.       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, 
  210.        jsize len);
  211.     jclass (JNICALL *FindClass)
  212.       (JNIEnv *env, const char *name);
  213.  
  214.     void *reserved4;
  215.     void *reserved5;
  216.     void *reserved6;
  217.  
  218.     jclass (JNICALL *GetSuperclass)
  219.       (JNIEnv *env, jclass sub);
  220.     jboolean (JNICALL *IsAssignableFrom)
  221.       (JNIEnv *env, jclass sub, jclass sup);
  222.     void *reserved7;
  223.  
  224.  
  225.     jint (JNICALL *Throw)
  226.       (JNIEnv *env, jthrowable obj);
  227.     jint (JNICALL *ThrowNew)
  228.       (JNIEnv *env, jclass clazz, const char *msg);
  229.     jthrowable (JNICALL *ExceptionOccurred)
  230.       (JNIEnv *env);
  231.     void (JNICALL *ExceptionDescribe)
  232.       (JNIEnv *env);
  233.     void (JNICALL *ExceptionClear)
  234.       (JNIEnv *env);
  235.     void (JNICALL *FatalError)
  236.       (JNIEnv *env, const char *msg);
  237.     void *reserved8;
  238.     void *reserved9;
  239.  
  240.     jobject (JNICALL *NewGlobalRef)
  241.       (JNIEnv *env, jobject lobj);
  242.     void (JNICALL *DeleteGlobalRef)
  243.       (JNIEnv *env, jobject gref);
  244.     void (JNICALL *DeleteLocalRef)
  245.       (JNIEnv *env, jobject obj);
  246.     jboolean (JNICALL *IsSameObject)
  247.       (JNIEnv *env, jobject obj1, jobject obj2);
  248.     void *reserved10;
  249.     void *reserved11;
  250.  
  251.     jobject (JNICALL *AllocObject)
  252.       (JNIEnv *env, jclass clazz);
  253.     jobject (JNICALL *NewObject)
  254.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  255.     jobject (JNICALL *NewObjectV)
  256.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  257.     jobject (JNICALL *NewObjectA)
  258.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  259.  
  260.     jclass (JNICALL *GetObjectClass)
  261.       (JNIEnv *env, jobject obj);
  262.     jboolean (JNICALL *IsInstanceOf)
  263.       (JNIEnv *env, jobject obj, jclass clazz);
  264.  
  265.     jmethodID (JNICALL *GetMethodID)
  266.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  267.  
  268.     jobject (JNICALL *CallObjectMethod)
  269.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  270.     jobject (JNICALL *CallObjectMethodV)
  271.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  272.     jobject (JNICALL *CallObjectMethodA)
  273.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  274.  
  275.     jboolean (JNICALL *CallBooleanMethod)
  276.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  277.     jboolean (JNICALL *CallBooleanMethodV)
  278.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  279.     jboolean (JNICALL *CallBooleanMethodA)
  280.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  281.  
  282.     jbyte (JNICALL *CallByteMethod)
  283.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  284.     jbyte (JNICALL *CallByteMethodV)
  285.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  286.     jbyte (JNICALL *CallByteMethodA)
  287.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  288.  
  289.     jchar (JNICALL *CallCharMethod)
  290.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  291.     jchar (JNICALL *CallCharMethodV)
  292.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  293.     jchar (JNICALL *CallCharMethodA)
  294.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  295.  
  296.     jshort (JNICALL *CallShortMethod)
  297.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  298.     jshort (JNICALL *CallShortMethodV)
  299.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  300.     jshort (JNICALL *CallShortMethodA)
  301.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  302.  
  303.     jint (JNICALL *CallIntMethod)
  304.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  305.     jint (JNICALL *CallIntMethodV)
  306.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  307.     jint (JNICALL *CallIntMethodA)
  308.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  309.  
  310.     jlong (JNICALL *CallLongMethod)
  311.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  312.     jlong (JNICALL *CallLongMethodV)
  313.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  314.     jlong (JNICALL *CallLongMethodA)
  315.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  316.  
  317.     jfloat (JNICALL *CallFloatMethod)
  318.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  319.     jfloat (JNICALL *CallFloatMethodV)
  320.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  321.     jfloat (JNICALL *CallFloatMethodA)
  322.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  323.  
  324.     jdouble (JNICALL *CallDoubleMethod)
  325.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  326.     jdouble (JNICALL *CallDoubleMethodV)
  327.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  328.     jdouble (JNICALL *CallDoubleMethodA)
  329.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  330.  
  331.     void (JNICALL *CallVoidMethod)
  332.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  333.     void (JNICALL *CallVoidMethodV)
  334.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  335.     void (JNICALL *CallVoidMethodA)
  336.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  337.  
  338.     jobject (JNICALL *CallNonvirtualObjectMethod)
  339.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  340.     jobject (JNICALL *CallNonvirtualObjectMethodV)
  341.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  342.        va_list args);
  343.     jobject (JNICALL *CallNonvirtualObjectMethodA)
  344.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  345.        jvalue * args);
  346.  
  347.     jboolean (JNICALL *CallNonvirtualBooleanMethod)
  348.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  349.     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
  350.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  351.        va_list args);
  352.     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
  353.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  354.        jvalue * args);
  355.  
  356.     jbyte (JNICALL *CallNonvirtualByteMethod)
  357.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  358.     jbyte (JNICALL *CallNonvirtualByteMethodV)
  359.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  360.        va_list args);
  361.     jbyte (JNICALL *CallNonvirtualByteMethodA)
  362.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  363.        jvalue *args);
  364.  
  365.     jchar (JNICALL *CallNonvirtualCharMethod)
  366.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  367.     jchar (JNICALL *CallNonvirtualCharMethodV)
  368.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  369.        va_list args);
  370.     jchar (JNICALL *CallNonvirtualCharMethodA)
  371.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  372.        jvalue *args);
  373.  
  374.     jshort (JNICALL *CallNonvirtualShortMethod)
  375.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  376.     jshort (JNICALL *CallNonvirtualShortMethodV)
  377.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  378.        va_list args);
  379.     jshort (JNICALL *CallNonvirtualShortMethodA)
  380.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  381.        jvalue *args);
  382.  
  383.     jint (JNICALL *CallNonvirtualIntMethod)
  384.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  385.     jint (JNICALL *CallNonvirtualIntMethodV)
  386.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  387.        va_list args);
  388.     jint (JNICALL *CallNonvirtualIntMethodA)
  389.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  390.        jvalue *args);
  391.  
  392.     jlong (JNICALL *CallNonvirtualLongMethod)
  393.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  394.     jlong (JNICALL *CallNonvirtualLongMethodV)
  395.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  396.        va_list args);
  397.     jlong (JNICALL *CallNonvirtualLongMethodA)
  398.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 
  399.        jvalue *args);
  400.  
  401.     jfloat (JNICALL *CallNonvirtualFloatMethod)
  402.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  403.     jfloat (JNICALL *CallNonvirtualFloatMethodV)
  404.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  405.        va_list args);
  406.     jfloat (JNICALL *CallNonvirtualFloatMethodA)
  407.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  408.        jvalue *args);
  409.  
  410.     jdouble (JNICALL *CallNonvirtualDoubleMethod)
  411.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  412.     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
  413.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  414.        va_list args);
  415.     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
  416.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  417.        jvalue *args);
  418.  
  419.     void (JNICALL *CallNonvirtualVoidMethod)
  420.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  421.     void (JNICALL *CallNonvirtualVoidMethodV)
  422.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  423.        va_list args);
  424.     void (JNICALL *CallNonvirtualVoidMethodA)
  425.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  426.        jvalue * args);
  427.  
  428.     jfieldID (JNICALL *GetFieldID)
  429.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  430.  
  431.     jobject (JNICALL *GetObjectField)
  432.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  433.     jboolean (JNICALL *GetBooleanField)
  434.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  435.     jbyte (JNICALL *GetByteField)
  436.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  437.     jchar (JNICALL *GetCharField)
  438.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  439.     jshort (JNICALL *GetShortField)
  440.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  441.     jint (JNICALL *GetIntField)
  442.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  443.     jlong (JNICALL *GetLongField)
  444.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  445.     jfloat (JNICALL *GetFloatField)
  446.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  447.     jdouble (JNICALL *GetDoubleField)
  448.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  449.  
  450.     void (JNICALL *SetObjectField)
  451.       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
  452.     void (JNICALL *SetBooleanField)
  453.       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
  454.     void (JNICALL *SetByteField)
  455.       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
  456.     void (JNICALL *SetCharField)
  457.       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
  458.     void (JNICALL *SetShortField)
  459.       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
  460.     void (JNICALL *SetIntField)
  461.       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
  462.     void (JNICALL *SetLongField)
  463.       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
  464.     void (JNICALL *SetFloatField)
  465.       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
  466.     void (JNICALL *SetDoubleField)
  467.       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
  468.  
  469.     jmethodID (JNICALL *GetStaticMethodID)
  470.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  471.  
  472.     jobject (JNICALL *CallStaticObjectMethod)
  473.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  474.     jobject (JNICALL *CallStaticObjectMethodV)
  475.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  476.     jobject (JNICALL *CallStaticObjectMethodA)
  477.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  478.  
  479.     jboolean (JNICALL *CallStaticBooleanMethod)
  480.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  481.     jboolean (JNICALL *CallStaticBooleanMethodV)
  482.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  483.     jboolean (JNICALL *CallStaticBooleanMethodA)
  484.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  485.  
  486.     jbyte (JNICALL *CallStaticByteMethod)
  487.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  488.     jbyte (JNICALL *CallStaticByteMethodV)
  489.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  490.     jbyte (JNICALL *CallStaticByteMethodA)
  491.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  492.  
  493.     jchar (JNICALL *CallStaticCharMethod)
  494.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  495.     jchar (JNICALL *CallStaticCharMethodV)
  496.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  497.     jchar (JNICALL *CallStaticCharMethodA)
  498.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  499.  
  500.     jshort (JNICALL *CallStaticShortMethod)
  501.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  502.     jshort (JNICALL *CallStaticShortMethodV)
  503.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  504.     jshort (JNICALL *CallStaticShortMethodA)
  505.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  506.  
  507.     jint (JNICALL *CallStaticIntMethod)
  508.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  509.     jint (JNICALL *CallStaticIntMethodV)
  510.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  511.     jint (JNICALL *CallStaticIntMethodA)
  512.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  513.  
  514.     jlong (JNICALL *CallStaticLongMethod)
  515.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  516.     jlong (JNICALL *CallStaticLongMethodV)
  517.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  518.     jlong (JNICALL *CallStaticLongMethodA)
  519.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  520.  
  521.     jfloat (JNICALL *CallStaticFloatMethod)
  522.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  523.     jfloat (JNICALL *CallStaticFloatMethodV)
  524.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  525.     jfloat (JNICALL *CallStaticFloatMethodA)
  526.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  527.  
  528.     jdouble (JNICALL *CallStaticDoubleMethod)
  529.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  530.     jdouble (JNICALL *CallStaticDoubleMethodV)
  531.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  532.     jdouble (JNICALL *CallStaticDoubleMethodA)       
  533.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  534.  
  535.     void (JNICALL *CallStaticVoidMethod)
  536.       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
  537.     void (JNICALL *CallStaticVoidMethodV)
  538.       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
  539.     void (JNICALL *CallStaticVoidMethodA)
  540.       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
  541.  
  542.     jfieldID (JNICALL *GetStaticFieldID)
  543.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  544.     jobject (JNICALL *GetStaticObjectField)
  545.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  546.     jboolean (JNICALL *GetStaticBooleanField)
  547.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  548.     jbyte (JNICALL *GetStaticByteField)
  549.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  550.     jchar (JNICALL *GetStaticCharField)
  551.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  552.     jshort (JNICALL *GetStaticShortField)
  553.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  554.     jint (JNICALL *GetStaticIntField)
  555.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  556.     jlong (JNICALL *GetStaticLongField)
  557.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  558.     jfloat (JNICALL *GetStaticFloatField)
  559.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  560.     jdouble (JNICALL *GetStaticDoubleField)
  561.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  562.  
  563.     void (JNICALL *SetStaticObjectField)
  564.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
  565.     void (JNICALL *SetStaticBooleanField)
  566.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
  567.     void (JNICALL *SetStaticByteField)
  568.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
  569.     void (JNICALL *SetStaticCharField)
  570.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
  571.     void (JNICALL *SetStaticShortField)
  572.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
  573.     void (JNICALL *SetStaticIntField)
  574.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
  575.     void (JNICALL *SetStaticLongField)
  576.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
  577.     void (JNICALL *SetStaticFloatField)
  578.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
  579.     void (JNICALL *SetStaticDoubleField)
  580.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
  581.  
  582.     jstring (JNICALL *NewString)
  583.       (JNIEnv *env, const jchar *unicode, jsize len);
  584.     jsize (JNICALL *GetStringLength)
  585.       (JNIEnv *env, jstring str);
  586.     const jchar *(JNICALL *GetStringChars)
  587.       (JNIEnv *env, jstring str, jboolean *isCopy);
  588.     void (JNICALL *ReleaseStringChars)
  589.       (JNIEnv *env, jstring str, const jchar *chars);
  590.   
  591.     jstring (JNICALL *NewStringUTF)
  592.       (JNIEnv *env, const char *utf);
  593.     jsize (JNICALL *GetStringUTFLength)
  594.       (JNIEnv *env, jstring str);
  595.     const char* (JNICALL *GetStringUTFChars)
  596.       (JNIEnv *env, jstring str, jboolean *isCopy);
  597.     void (JNICALL *ReleaseStringUTFChars)
  598.       (JNIEnv *env, jstring str, const char* chars);
  599.   
  600.  
  601.     jsize (JNICALL *GetArrayLength)
  602.       (JNIEnv *env, jarray array);
  603.  
  604.     jobjectArray (JNICALL *NewObjectArray)
  605.       (JNIEnv *env, jsize len, jclass clazz, jobject init);
  606.     jobject (JNICALL *GetObjectArrayElement)
  607.       (JNIEnv *env, jobjectArray array, jsize index);
  608.     void (JNICALL *SetObjectArrayElement)
  609.       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
  610.  
  611.     jbooleanArray (JNICALL *NewBooleanArray)
  612.       (JNIEnv *env, jsize len);
  613.     jbyteArray (JNICALL *NewByteArray)
  614.       (JNIEnv *env, jsize len);
  615.     jcharArray (JNICALL *NewCharArray)
  616.       (JNIEnv *env, jsize len);
  617.     jshortArray (JNICALL *NewShortArray)
  618.       (JNIEnv *env, jsize len);
  619.     jintArray (JNICALL *NewIntArray)
  620.       (JNIEnv *env, jsize len);
  621.     jlongArray (JNICALL *NewLongArray)
  622.       (JNIEnv *env, jsize len);
  623.     jfloatArray (JNICALL *NewFloatArray)
  624.       (JNIEnv *env, jsize len);
  625.     jdoubleArray (JNICALL *NewDoubleArray)
  626.       (JNIEnv *env, jsize len);
  627.  
  628.     jboolean * (JNICALL *GetBooleanArrayElements)
  629.       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
  630.     jbyte * (JNICALL *GetByteArrayElements)
  631.       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
  632.     jchar * (JNICALL *GetCharArrayElements)
  633.       (JNIEnv *env, jcharArray array, jboolean *isCopy);
  634.     jshort * (JNICALL *GetShortArrayElements)
  635.       (JNIEnv *env, jshortArray array, jboolean *isCopy);
  636.     jint * (JNICALL *GetIntArrayElements)
  637.       (JNIEnv *env, jintArray array, jboolean *isCopy);
  638.     jlong * (JNICALL *GetLongArrayElements)
  639.       (JNIEnv *env, jlongArray array, jboolean *isCopy);
  640.     jfloat * (JNICALL *GetFloatArrayElements)
  641.       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
  642.     jdouble * (JNICALL *GetDoubleArrayElements)
  643.       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
  644.  
  645.     void (JNICALL *ReleaseBooleanArrayElements)
  646.       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
  647.     void (JNICALL *ReleaseByteArrayElements)
  648.       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
  649.     void (JNICALL *ReleaseCharArrayElements)
  650.       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
  651.     void (JNICALL *ReleaseShortArrayElements)
  652.       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
  653.     void (JNICALL *ReleaseIntArrayElements)
  654.       (JNIEnv *env, jintArray array, jint *elems, jint mode);
  655.     void (JNICALL *ReleaseLongArrayElements)
  656.       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
  657.     void (JNICALL *ReleaseFloatArrayElements)
  658.       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
  659.     void (JNICALL *ReleaseDoubleArrayElements)
  660.       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
  661.  
  662.     void (JNICALL *GetBooleanArrayRegion)
  663.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  664.     void (JNICALL *GetByteArrayRegion)
  665.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  666.     void (JNICALL *GetCharArrayRegion)
  667.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  668.     void (JNICALL *GetShortArrayRegion)
  669.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  670.     void (JNICALL *GetIntArrayRegion)
  671.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  672.     void (JNICALL *GetLongArrayRegion)
  673.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  674.     void (JNICALL *GetFloatArrayRegion)
  675.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  676.     void (JNICALL *GetDoubleArrayRegion)
  677.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  678.  
  679.     void (JNICALL *SetBooleanArrayRegion)
  680.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  681.     void (JNICALL *SetByteArrayRegion)
  682.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  683.     void (JNICALL *SetCharArrayRegion)
  684.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  685.     void (JNICALL *SetShortArrayRegion)
  686.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  687.     void (JNICALL *SetIntArrayRegion)
  688.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  689.     void (JNICALL *SetLongArrayRegion)
  690.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  691.     void (JNICALL *SetFloatArrayRegion)
  692.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  693.     void (JNICALL *SetDoubleArrayRegion)
  694.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  695.  
  696.     jint (JNICALL *RegisterNatives)
  697.       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, 
  698.        jint nMethods);
  699.     jint (JNICALL *UnregisterNatives)
  700.       (JNIEnv *env, jclass clazz);
  701.  
  702.     jint (JNICALL *MonitorEnter)
  703.       (JNIEnv *env, jobject obj);
  704.     jint (JNICALL *MonitorExit)
  705.       (JNIEnv *env, jobject obj);
  706.  
  707.     jint (JNICALL *GetJavaVM)
  708.       (JNIEnv *env, JavaVM **vm);
  709. };
  710.  
  711. /*
  712.  * We use inlined functions for C++ so that programmers can write:
  713.  * 
  714.  *    env->FindClass("java/lang/String")
  715.  *
  716.  * in C++ rather than:
  717.  *
  718.  *    (*env)->FindClass(env, "java/lang/String")
  719.  *
  720.  * in C.
  721.  */
  722.  
  723. struct JNIEnv_ {
  724.     const struct JNINativeInterface_ *functions;
  725.     void *reserved0;
  726.     void *reserved1[6];
  727. #ifdef __cplusplus
  728.  
  729.     jint GetVersion() {
  730.         return functions->GetVersion(this);
  731.     }
  732.     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
  733.                jsize len) {
  734.         return functions->DefineClass(this, name, loader, buf, len);
  735.     }
  736.     jclass FindClass(const char *name) {
  737.         return functions->FindClass(this, name);
  738.     }
  739.     jclass GetSuperclass(jclass sub) {
  740.         return functions->GetSuperclass(this, sub);
  741.     }
  742.     jboolean IsAssignableFrom(jclass sub, jclass sup) {
  743.         return functions->IsAssignableFrom(this, sub, sup);
  744.     }
  745.  
  746.     jint Throw(jthrowable obj) {
  747.         return functions->Throw(this, obj);
  748.     }    
  749.     jint ThrowNew(jclass clazz, const char *msg) {
  750.         return functions->ThrowNew(this, clazz, msg);
  751.     }
  752.     jthrowable ExceptionOccurred() {
  753.         return functions->ExceptionOccurred(this);
  754.     }
  755.     void ExceptionDescribe() {
  756.         functions->ExceptionDescribe(this);
  757.     }
  758.     void ExceptionClear() {
  759.         functions->ExceptionClear(this);
  760.     }
  761.     void FatalError(const char *msg) {
  762.         functions->FatalError(this, msg);
  763.     }
  764.  
  765.     jobject NewGlobalRef(jobject lobj) {
  766.         return functions->NewGlobalRef(this,lobj);
  767.     }
  768.     void DeleteGlobalRef(jobject gref) {
  769.         functions->DeleteGlobalRef(this,gref);
  770.     }
  771.     void DeleteLocalRef(jobject obj) {
  772.         functions->DeleteLocalRef(this, obj);
  773.     }
  774.  
  775.     jboolean IsSameObject(jobject obj1, jobject obj2) {
  776.         return functions->IsSameObject(this,obj1,obj2);
  777.     }
  778.  
  779.     jobject AllocObject(jclass clazz) {
  780.         return functions->AllocObject(this,clazz);
  781.     }
  782.     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
  783.         va_list args;
  784.     jobject result;
  785.     va_start(args, methodID);
  786.         result = functions->NewObjectV(this,clazz,methodID,args);
  787.     va_end(args);
  788.     return result;
  789.     }
  790.     jobject NewObjectV(jclass clazz, jmethodID methodID, 
  791.                va_list args) {
  792.         return functions->NewObjectV(this,clazz,methodID,args);
  793.     }
  794.     jobject NewObjectA(jclass clazz, jmethodID methodID, 
  795.                jvalue *args) {
  796.         return functions->NewObjectA(this,clazz,methodID,args);
  797.     }
  798.  
  799.     jclass GetObjectClass(jobject obj) {
  800.         return functions->GetObjectClass(this,obj);
  801.     }
  802.     jboolean IsInstanceOf(jobject obj, jclass clazz) {
  803.         return functions->IsInstanceOf(this,obj,clazz);
  804.     }
  805.  
  806.     jmethodID GetMethodID(jclass clazz, const char *name, 
  807.               const char *sig) {
  808.         return functions->GetMethodID(this,clazz,name,sig);
  809.     }
  810.  
  811.     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
  812.         va_list args;
  813.     jobject result;
  814.     va_start(args,methodID);
  815.     result = functions->CallObjectMethodV(this,obj,methodID,args);
  816.     va_end(args);
  817.     return result;
  818.     }
  819.     jobject CallObjectMethodV(jobject obj, jmethodID methodID, 
  820.             va_list args) {
  821.         return functions->CallObjectMethodV(this,obj,methodID,args);
  822.     }
  823.     jobject CallObjectMethodA(jobject obj, jmethodID methodID, 
  824.             jvalue * args) {
  825.         return functions->CallObjectMethodA(this,obj,methodID,args);
  826.     }
  827.  
  828.     jboolean CallBooleanMethod(jobject obj, 
  829.                    jmethodID methodID, ...) {
  830.         va_list args;
  831.     jboolean result;
  832.     va_start(args,methodID);
  833.     result = functions->CallBooleanMethodV(this,obj,methodID,args);
  834.     va_end(args);
  835.     return result;
  836.     }
  837.     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, 
  838.                 va_list args) {
  839.         return functions->CallBooleanMethodV(this,obj,methodID,args);
  840.     }
  841.     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, 
  842.                 jvalue * args) {
  843.         return functions->CallBooleanMethodA(this,obj,methodID, args);
  844.     }
  845.  
  846.     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
  847.         va_list args;
  848.     jbyte result;
  849.     va_start(args,methodID);
  850.     result = functions->CallByteMethodV(this,obj,methodID,args);
  851.     va_end(args);
  852.     return result;
  853.     }
  854.     jbyte CallByteMethodV(jobject obj, jmethodID methodID, 
  855.               va_list args) {
  856.         return functions->CallByteMethodV(this,obj,methodID,args);
  857.     }
  858.     jbyte CallByteMethodA(jobject obj, jmethodID methodID, 
  859.               jvalue * args) {
  860.         return functions->CallByteMethodA(this,obj,methodID,args);
  861.     }
  862.  
  863.     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
  864.         va_list args;
  865.     jchar result;
  866.     va_start(args,methodID);
  867.     result = functions->CallCharMethodV(this,obj,methodID,args);
  868.     va_end(args);
  869.     return result;
  870.     }
  871.     jchar CallCharMethodV(jobject obj, jmethodID methodID, 
  872.               va_list args) {
  873.         return functions->CallCharMethodV(this,obj,methodID,args);
  874.     }
  875.     jchar CallCharMethodA(jobject obj, jmethodID methodID, 
  876.               jvalue * args) {
  877.         return functions->CallCharMethodA(this,obj,methodID,args);
  878.     }
  879.  
  880.     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
  881.         va_list args;
  882.     jshort result;
  883.     va_start(args,methodID);
  884.     result = functions->CallShortMethodV(this,obj,methodID,args);
  885.     va_end(args);
  886.     return result;
  887.     }
  888.     jshort CallShortMethodV(jobject obj, jmethodID methodID, 
  889.                 va_list args) {
  890.         return functions->CallShortMethodV(this,obj,methodID,args);
  891.     }
  892.     jshort CallShortMethodA(jobject obj, jmethodID methodID, 
  893.                 jvalue * args) {
  894.         return functions->CallShortMethodA(this,obj,methodID,args);
  895.     }
  896.  
  897.     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
  898.         va_list args;
  899.     jint result;
  900.     va_start(args,methodID);
  901.     result = functions->CallIntMethodV(this,obj,methodID,args);
  902.     va_end(args);
  903.     return result;
  904.     }
  905.     jint CallIntMethodV(jobject obj, jmethodID methodID, 
  906.             va_list args) {
  907.         return functions->CallIntMethodV(this,obj,methodID,args);
  908.     }
  909.     jint CallIntMethodA(jobject obj, jmethodID methodID, 
  910.             jvalue * args) {
  911.         return functions->CallIntMethodA(this,obj,methodID,args);
  912.     }
  913.  
  914.     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
  915.         va_list args;
  916.     jlong result;
  917.     va_start(args,methodID);
  918.     result = functions->CallLongMethodV(this,obj,methodID,args);
  919.     va_end(args);
  920.     return result;
  921.     }
  922.     jlong CallLongMethodV(jobject obj, jmethodID methodID, 
  923.               va_list args) {
  924.         return functions->CallLongMethodV(this,obj,methodID,args);
  925.     }
  926.     jlong CallLongMethodA(jobject obj, jmethodID methodID, 
  927.               jvalue * args) {
  928.         return functions->CallLongMethodA(this,obj,methodID,args);
  929.     }
  930.  
  931.     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
  932.         va_list args;
  933.     jfloat result;
  934.     va_start(args,methodID);
  935.     result = functions->CallFloatMethodV(this,obj,methodID,args);
  936.     va_end(args);
  937.     return result;
  938.     }
  939.     jfloat CallFloatMethodV(jobject obj, jmethodID methodID, 
  940.                 va_list args) {
  941.         return functions->CallFloatMethodV(this,obj,methodID,args);
  942.     }
  943.     jfloat CallFloatMethodA(jobject obj, jmethodID methodID, 
  944.                 jvalue * args) {
  945.         return functions->CallFloatMethodA(this,obj,methodID,args);
  946.     }
  947.  
  948.     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
  949.         va_list args;
  950.     jdouble result;
  951.     va_start(args,methodID);
  952.     result = functions->CallDoubleMethodV(this,obj,methodID,args);
  953.     va_end(args);
  954.     return result;
  955.     }
  956.     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, 
  957.             va_list args) {
  958.         return functions->CallDoubleMethodV(this,obj,methodID,args);
  959.     }
  960.     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, 
  961.             jvalue * args) {
  962.         return functions->CallDoubleMethodA(this,obj,methodID,args);
  963.     }
  964.  
  965.     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
  966.         va_list args;
  967.     va_start(args,methodID);
  968.     functions->CallVoidMethodV(this,obj,methodID,args);
  969.     va_end(args);
  970.     }
  971.     void CallVoidMethodV(jobject obj, jmethodID methodID, 
  972.              va_list args) {
  973.         functions->CallVoidMethodV(this,obj,methodID,args);
  974.     }
  975.     void CallVoidMethodA(jobject obj, jmethodID methodID, 
  976.              jvalue * args) {
  977.         functions->CallVoidMethodA(this,obj,methodID,args);
  978.     }
  979.  
  980.     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, 
  981.                        jmethodID methodID, ...) {
  982.         va_list args;
  983.     jobject result;
  984.     va_start(args,methodID);
  985.     result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  986.                             methodID,args);
  987.     va_end(args);
  988.     return result;
  989.     }
  990.     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, 
  991.                     jmethodID methodID, va_list args) {
  992.         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  993.                               methodID,args);
  994.     }
  995.     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, 
  996.                     jmethodID methodID, jvalue * args) {
  997.         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
  998.                               methodID,args);
  999.     }
  1000.  
  1001.     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, 
  1002.                      jmethodID methodID, ...) {
  1003.         va_list args;
  1004.     jboolean result;
  1005.     va_start(args,methodID);
  1006.     result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1007.                              methodID,args);
  1008.     va_end(args);
  1009.     return result;
  1010.     }
  1011.     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, 
  1012.                       jmethodID methodID, va_list args) {
  1013.         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1014.                                methodID,args);
  1015.     }
  1016.     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, 
  1017.                       jmethodID methodID, jvalue * args) {
  1018.         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
  1019.                                methodID, args);
  1020.     }
  1021.  
  1022.     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, 
  1023.                    jmethodID methodID, ...) {
  1024.         va_list args;
  1025.     jbyte result;
  1026.     va_start(args,methodID);
  1027.     result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1028.                               methodID,args);
  1029.     va_end(args);
  1030.     return result;
  1031.     }
  1032.     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, 
  1033.                     jmethodID methodID, va_list args) {
  1034.         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1035.                             methodID,args);
  1036.     }
  1037.     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, 
  1038.                     jmethodID methodID, jvalue * args) {
  1039.         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
  1040.                             methodID,args);
  1041.     }
  1042.  
  1043.     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, 
  1044.                    jmethodID methodID, ...) {
  1045.         va_list args;
  1046.     jchar result;
  1047.     va_start(args,methodID);
  1048.     result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1049.                               methodID,args);
  1050.     va_end(args);
  1051.     return result;
  1052.     }
  1053.     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, 
  1054.                     jmethodID methodID, va_list args) {
  1055.         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1056.                             methodID,args);
  1057.     }
  1058.     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, 
  1059.                     jmethodID methodID, jvalue * args) {
  1060.         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
  1061.                             methodID,args);
  1062.     }
  1063.  
  1064.     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, 
  1065.                      jmethodID methodID, ...) {
  1066.         va_list args;
  1067.     jshort result;
  1068.     va_start(args,methodID);
  1069.     result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1070.                                methodID,args);
  1071.     va_end(args);
  1072.     return result;
  1073.     }
  1074.     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, 
  1075.                       jmethodID methodID, va_list args) {
  1076.         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1077.                              methodID,args);
  1078.     }
  1079.     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
  1080.                       jmethodID methodID, jvalue * args) {
  1081.         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
  1082.                              methodID,args);
  1083.     }
  1084.  
  1085.     jint CallNonvirtualIntMethod(jobject obj, jclass clazz, 
  1086.                  jmethodID methodID, ...) {
  1087.         va_list args;
  1088.     jint result;
  1089.     va_start(args,methodID);
  1090.     result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1091.                              methodID,args);
  1092.     va_end(args);
  1093.     return result;
  1094.     }
  1095.     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, 
  1096.                   jmethodID methodID, va_list args) {
  1097.         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1098.                            methodID,args);
  1099.     }
  1100.     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, 
  1101.                   jmethodID methodID, jvalue * args) {
  1102.         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
  1103.                            methodID,args);
  1104.     }
  1105.  
  1106.     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
  1107.                    jmethodID methodID, ...) {
  1108.         va_list args;
  1109.     jlong result;
  1110.     va_start(args,methodID);
  1111.     result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1112.                               methodID,args);
  1113.     va_end(args);
  1114.     return result;
  1115.     }
  1116.     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
  1117.                     jmethodID methodID, va_list args) {
  1118.         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1119.                             methodID,args);
  1120.     }
  1121.     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, 
  1122.                     jmethodID methodID, jvalue * args) {
  1123.         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
  1124.                             methodID,args);
  1125.     }
  1126.  
  1127.     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, 
  1128.                      jmethodID methodID, ...) {
  1129.         va_list args;
  1130.     jfloat result;
  1131.     va_start(args,methodID);
  1132.     result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1133.                                methodID,args);
  1134.     va_end(args);
  1135.     return result;
  1136.     }
  1137.     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
  1138.                       jmethodID methodID, 
  1139.                       va_list args) {
  1140.         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1141.                              methodID,args);
  1142.     }
  1143.     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, 
  1144.                       jmethodID methodID, 
  1145.                       jvalue * args) {
  1146.         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
  1147.                              methodID,args);
  1148.     }
  1149.  
  1150.     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
  1151.                        jmethodID methodID, ...) {
  1152.         va_list args;
  1153.     jdouble result;
  1154.     va_start(args,methodID);
  1155.     result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1156.                             methodID,args);
  1157.     va_end(args);
  1158.     return result;
  1159.     }
  1160.     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
  1161.                     jmethodID methodID, 
  1162.                     va_list args) {
  1163.         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1164.                               methodID,args);
  1165.     }
  1166.     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, 
  1167.                     jmethodID methodID, 
  1168.                     jvalue * args) {
  1169.         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
  1170.                               methodID,args);
  1171.     }
  1172.  
  1173.     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
  1174.                   jmethodID methodID, ...) {
  1175.         va_list args;
  1176.     va_start(args,methodID);
  1177.     functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1178.     va_end(args);
  1179.     }
  1180.     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
  1181.                    jmethodID methodID, 
  1182.                    va_list args) {
  1183.         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1184.     }
  1185.     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
  1186.                    jmethodID methodID, 
  1187.                    jvalue * args) {
  1188.         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
  1189.     }
  1190.  
  1191.     jfieldID GetFieldID(jclass clazz, const char *name, 
  1192.             const char *sig) {
  1193.         return functions->GetFieldID(this,clazz,name,sig);
  1194.     }
  1195.  
  1196.     jobject GetObjectField(jobject obj, jfieldID fieldID) {
  1197.         return functions->GetObjectField(this,obj,fieldID);
  1198.     }
  1199.     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
  1200.         return functions->GetBooleanField(this,obj,fieldID);
  1201.     }
  1202.     jbyte GetByteField(jobject obj, jfieldID fieldID) {
  1203.         return functions->GetByteField(this,obj,fieldID);
  1204.     }
  1205.     jchar GetCharField(jobject obj, jfieldID fieldID) {
  1206.         return functions->GetCharField(this,obj,fieldID);
  1207.     }
  1208.     jshort GetShortField(jobject obj, jfieldID fieldID) {
  1209.         return functions->GetShortField(this,obj,fieldID);
  1210.     }
  1211.     jint GetIntField(jobject obj, jfieldID fieldID) {
  1212.         return functions->GetIntField(this,obj,fieldID);
  1213.     }
  1214.     jlong GetLongField(jobject obj, jfieldID fieldID) {
  1215.         return functions->GetLongField(this,obj,fieldID);
  1216.     }
  1217.     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
  1218.         return functions->GetFloatField(this,obj,fieldID);
  1219.     }
  1220.     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
  1221.         return functions->GetDoubleField(this,obj,fieldID);
  1222.     }
  1223.  
  1224.     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
  1225.         functions->SetObjectField(this,obj,fieldID,val);
  1226.     }
  1227.     void SetBooleanField(jobject obj, jfieldID fieldID, 
  1228.              jboolean val) {
  1229.         functions->SetBooleanField(this,obj,fieldID,val);
  1230.     }
  1231.     void SetByteField(jobject obj, jfieldID fieldID, 
  1232.               jbyte val) {
  1233.         functions->SetByteField(this,obj,fieldID,val);
  1234.     }
  1235.     void SetCharField(jobject obj, jfieldID fieldID, 
  1236.               jchar val) {
  1237.         functions->SetCharField(this,obj,fieldID,val);
  1238.     }
  1239.     void SetShortField(jobject obj, jfieldID fieldID,
  1240.                jshort val) {
  1241.         functions->SetShortField(this,obj,fieldID,val);
  1242.     }
  1243.     void SetIntField(jobject obj, jfieldID fieldID, 
  1244.              jint val) {
  1245.         functions->SetIntField(this,obj,fieldID,val);
  1246.     }
  1247.     void SetLongField(jobject obj, jfieldID fieldID, 
  1248.               jlong val) {
  1249.         functions->SetLongField(this,obj,fieldID,val);
  1250.     }
  1251.     void SetFloatField(jobject obj, jfieldID fieldID, 
  1252.                jfloat val) {
  1253.         functions->SetFloatField(this,obj,fieldID,val);
  1254.     }
  1255.     void SetDoubleField(jobject obj, jfieldID fieldID, 
  1256.             jdouble val) {
  1257.         functions->SetDoubleField(this,obj,fieldID,val);
  1258.     }
  1259.  
  1260.     jmethodID GetStaticMethodID(jclass clazz, const char *name, 
  1261.                 const char *sig) {
  1262.         return functions->GetStaticMethodID(this,clazz,name,sig);
  1263.     }
  1264.  
  1265.     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, 
  1266.                  ...) {
  1267.         va_list args;
  1268.     jobject result;
  1269.     va_start(args,methodID);
  1270.     result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1271.     va_end(args);
  1272.     return result;
  1273.     }
  1274.     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, 
  1275.                   va_list args) {
  1276.         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1277.     }
  1278.     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, 
  1279.                   jvalue *args) {
  1280.         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
  1281.     }
  1282.  
  1283.     jboolean CallStaticBooleanMethod(jclass clazz, 
  1284.                      jmethodID methodID, ...) {
  1285.         va_list args;
  1286.     jboolean result;
  1287.     va_start(args,methodID);
  1288.     result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1289.     va_end(args);
  1290.     return result;
  1291.     }
  1292.     jboolean CallStaticBooleanMethodV(jclass clazz,
  1293.                       jmethodID methodID, va_list args) {
  1294.         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1295.     }
  1296.     jboolean CallStaticBooleanMethodA(jclass clazz,
  1297.                       jmethodID methodID, jvalue *args) {
  1298.         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
  1299.     }
  1300.  
  1301.     jbyte CallStaticByteMethod(jclass clazz,
  1302.                    jmethodID methodID, ...) {
  1303.         va_list args;
  1304.     jbyte result;
  1305.     va_start(args,methodID);
  1306.     result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1307.     va_end(args);
  1308.     return result;
  1309.     }
  1310.     jbyte CallStaticByteMethodV(jclass clazz,
  1311.                 jmethodID methodID, va_list args) {
  1312.         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1313.     }
  1314.     jbyte CallStaticByteMethodA(jclass clazz, 
  1315.                 jmethodID methodID, jvalue *args) {
  1316.         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
  1317.     }
  1318.  
  1319.     jchar CallStaticCharMethod(jclass clazz,
  1320.                    jmethodID methodID, ...) {
  1321.         va_list args;
  1322.     jchar result;
  1323.     va_start(args,methodID);
  1324.     result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1325.     va_end(args);
  1326.     return result;
  1327.     }
  1328.     jchar CallStaticCharMethodV(jclass clazz,
  1329.                 jmethodID methodID, va_list args) {
  1330.         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1331.     }
  1332.     jchar CallStaticCharMethodA(jclass clazz,
  1333.                 jmethodID methodID, jvalue *args) {
  1334.         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
  1335.     }
  1336.  
  1337.     jshort CallStaticShortMethod(jclass clazz,
  1338.                  jmethodID methodID, ...) {
  1339.         va_list args;
  1340.     jshort result;
  1341.     va_start(args,methodID);
  1342.     result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1343.     va_end(args);
  1344.     return result;
  1345.     }
  1346.     jshort CallStaticShortMethodV(jclass clazz,
  1347.                   jmethodID methodID, va_list args) {
  1348.         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1349.     }
  1350.     jshort CallStaticShortMethodA(jclass clazz,
  1351.                   jmethodID methodID, jvalue *args) {
  1352.         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
  1353.     }
  1354.  
  1355.     jint CallStaticIntMethod(jclass clazz,
  1356.                  jmethodID methodID, ...) {
  1357.         va_list args;
  1358.     jint result;
  1359.     va_start(args,methodID);
  1360.     result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1361.     va_end(args);
  1362.     return result;
  1363.     }
  1364.     jint CallStaticIntMethodV(jclass clazz,
  1365.                   jmethodID methodID, va_list args) {
  1366.         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1367.     }
  1368.     jint CallStaticIntMethodA(jclass clazz, 
  1369.                   jmethodID methodID, jvalue *args) {
  1370.         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
  1371.     }
  1372.  
  1373.     jlong CallStaticLongMethod(jclass clazz,
  1374.                    jmethodID methodID, ...) {
  1375.         va_list args;
  1376.     jlong result;
  1377.     va_start(args,methodID);
  1378.     result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1379.     va_end(args);
  1380.     return result;
  1381.     }
  1382.     jlong CallStaticLongMethodV(jclass clazz, 
  1383.                 jmethodID methodID, va_list args) {
  1384.         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1385.     }
  1386.     jlong CallStaticLongMethodA(jclass clazz, 
  1387.                 jmethodID methodID, jvalue *args) {
  1388.         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
  1389.     }
  1390.  
  1391.     jfloat CallStaticFloatMethod(jclass clazz, 
  1392.                  jmethodID methodID, ...) {
  1393.         va_list args;
  1394.     jfloat result;
  1395.     va_start(args,methodID);
  1396.     result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1397.     va_end(args);
  1398.     return result;
  1399.     }
  1400.     jfloat CallStaticFloatMethodV(jclass clazz, 
  1401.                   jmethodID methodID, va_list args) {
  1402.         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1403.     }
  1404.     jfloat CallStaticFloatMethodA(jclass clazz, 
  1405.                   jmethodID methodID, jvalue *args) {
  1406.         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
  1407.     }
  1408.  
  1409.     jdouble CallStaticDoubleMethod(jclass clazz, 
  1410.                    jmethodID methodID, ...) {
  1411.         va_list args;
  1412.     jdouble result;
  1413.     va_start(args,methodID);
  1414.     result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1415.     va_end(args);
  1416.     return result;
  1417.     }
  1418.     jdouble CallStaticDoubleMethodV(jclass clazz, 
  1419.                     jmethodID methodID, va_list args) {
  1420.         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1421.     }
  1422.     jdouble CallStaticDoubleMethodA(jclass clazz, 
  1423.                     jmethodID methodID, jvalue *args) {
  1424.         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
  1425.     }
  1426.  
  1427.     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
  1428.         va_list args;
  1429.     va_start(args,methodID);
  1430.     functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1431.     va_end(args);
  1432.     }
  1433.     void CallStaticVoidMethodV(jclass cls, jmethodID methodID, 
  1434.                    va_list args) {
  1435.         functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1436.     }
  1437.     void CallStaticVoidMethodA(jclass cls, jmethodID methodID, 
  1438.                    jvalue * args) {
  1439.         functions->CallStaticVoidMethodA(this,cls,methodID,args);
  1440.     }
  1441.  
  1442.     jfieldID GetStaticFieldID(jclass clazz, const char *name, 
  1443.                   const char *sig) {
  1444.         return functions->GetStaticFieldID(this,clazz,name,sig);
  1445.     }
  1446.     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
  1447.         return functions->GetStaticObjectField(this,clazz,fieldID);
  1448.     }
  1449.     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
  1450.         return functions->GetStaticBooleanField(this,clazz,fieldID);
  1451.     }
  1452.     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
  1453.         return functions->GetStaticByteField(this,clazz,fieldID);
  1454.     }
  1455.     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
  1456.         return functions->GetStaticCharField(this,clazz,fieldID);
  1457.     }
  1458.     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
  1459.         return functions->GetStaticShortField(this,clazz,fieldID);
  1460.     }
  1461.     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
  1462.         return functions->GetStaticIntField(this,clazz,fieldID);
  1463.     }
  1464.     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
  1465.         return functions->GetStaticLongField(this,clazz,fieldID);
  1466.     }
  1467.     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
  1468.         return functions->GetStaticFloatField(this,clazz,fieldID);
  1469.     }
  1470.     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
  1471.         return functions->GetStaticDoubleField(this,clazz,fieldID);
  1472.     }
  1473.  
  1474.     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
  1475.             jobject value) {
  1476.       functions->SetStaticObjectField(this,clazz,fieldID,value);
  1477.     }
  1478.     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
  1479.             jboolean value) {
  1480.       functions->SetStaticBooleanField(this,clazz,fieldID,value);
  1481.     }
  1482.     void SetStaticByteField(jclass clazz, jfieldID fieldID,
  1483.             jbyte value) {
  1484.       functions->SetStaticByteField(this,clazz,fieldID,value);
  1485.     }
  1486.     void SetStaticCharField(jclass clazz, jfieldID fieldID,
  1487.             jchar value) {
  1488.       functions->SetStaticCharField(this,clazz,fieldID,value);
  1489.     }
  1490.     void SetStaticShortField(jclass clazz, jfieldID fieldID,
  1491.             jshort value) {
  1492.       functions->SetStaticShortField(this,clazz,fieldID,value);
  1493.     }
  1494.     void SetStaticIntField(jclass clazz, jfieldID fieldID,
  1495.             jint value) {
  1496.       functions->SetStaticIntField(this,clazz,fieldID,value);
  1497.     }
  1498.     void SetStaticLongField(jclass clazz, jfieldID fieldID,
  1499.             jlong value) {
  1500.       functions->SetStaticLongField(this,clazz,fieldID,value);
  1501.     }
  1502.     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
  1503.             jfloat value) {
  1504.       functions->SetStaticFloatField(this,clazz,fieldID,value);
  1505.     }
  1506.     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
  1507.             jdouble value) {
  1508.       functions->SetStaticDoubleField(this,clazz,fieldID,value);
  1509.     }
  1510.  
  1511.     jstring NewString(const jchar *unicode, jsize len) {
  1512.         return functions->NewString(this,unicode,len);
  1513.     }
  1514.     jsize GetStringLength(jstring str) {
  1515.         return functions->GetStringLength(this,str);
  1516.     }
  1517.     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
  1518.         return functions->GetStringChars(this,str,isCopy);
  1519.     }
  1520.     void ReleaseStringChars(jstring str, const jchar *chars) {
  1521.         functions->ReleaseStringChars(this,str,chars);
  1522.     }
  1523.   
  1524.     jstring NewStringUTF(const char *utf) {
  1525.         return functions->NewStringUTF(this,utf);
  1526.     }
  1527.     jsize GetStringUTFLength(jstring str) {
  1528.         return functions->GetStringUTFLength(this,str);
  1529.     }
  1530.     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
  1531.         return functions->GetStringUTFChars(this,str,isCopy);
  1532.     }
  1533.     void ReleaseStringUTFChars(jstring str, const char* chars) {
  1534.         functions->ReleaseStringUTFChars(this,str,chars);
  1535.     }
  1536.  
  1537.     jsize GetArrayLength(jarray array) {
  1538.         return functions->GetArrayLength(this,array);
  1539.     }
  1540.  
  1541.     jobjectArray NewObjectArray(jsize len, jclass clazz, 
  1542.                 jobject init) {
  1543.         return functions->NewObjectArray(this,len,clazz,init);
  1544.     }
  1545.     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
  1546.         return functions->GetObjectArrayElement(this,array,index);
  1547.     }
  1548.     void SetObjectArrayElement(jobjectArray array, jsize index, 
  1549.                    jobject val) {
  1550.         functions->SetObjectArrayElement(this,array,index,val);
  1551.     }
  1552.  
  1553.     jbooleanArray NewBooleanArray(jsize len) {
  1554.         return functions->NewBooleanArray(this,len);
  1555.     }
  1556.     jbyteArray NewByteArray(jsize len) {
  1557.         return functions->NewByteArray(this,len);
  1558.     }
  1559.     jcharArray NewCharArray(jsize len) {
  1560.         return functions->NewCharArray(this,len);
  1561.     }
  1562.     jshortArray NewShortArray(jsize len) {
  1563.         return functions->NewShortArray(this,len);
  1564.     }
  1565.     jintArray NewIntArray(jsize len) {
  1566.         return functions->NewIntArray(this,len);
  1567.     }
  1568.     jlongArray NewLongArray(jsize len) {
  1569.         return functions->NewLongArray(this,len);
  1570.     }
  1571.     jfloatArray NewFloatArray(jsize len) {
  1572.         return functions->NewFloatArray(this,len);
  1573.     }
  1574.     jdoubleArray NewDoubleArray(jsize len) {
  1575.         return functions->NewDoubleArray(this,len);
  1576.     }
  1577.  
  1578.     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
  1579.         return functions->GetBooleanArrayElements(this,array,isCopy);
  1580.     }
  1581.     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
  1582.         return functions->GetByteArrayElements(this,array,isCopy);
  1583.     }
  1584.     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
  1585.         return functions->GetCharArrayElements(this,array,isCopy);
  1586.     }
  1587.     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
  1588.         return functions->GetShortArrayElements(this,array,isCopy);
  1589.     }
  1590.     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
  1591.         return functions->GetIntArrayElements(this,array,isCopy);
  1592.     }
  1593.     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
  1594.         return functions->GetLongArrayElements(this,array,isCopy);
  1595.     }
  1596.     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
  1597.         return functions->GetFloatArrayElements(this,array,isCopy);
  1598.     }
  1599.     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
  1600.         return functions->GetDoubleArrayElements(this,array,isCopy);
  1601.     }
  1602.  
  1603.     void ReleaseBooleanArrayElements(jbooleanArray array, 
  1604.                      jboolean *elems,
  1605.                      jint mode) {
  1606.         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
  1607.     }
  1608.     void ReleaseByteArrayElements(jbyteArray array, 
  1609.                   jbyte *elems,
  1610.                   jint mode) {
  1611.         functions->ReleaseByteArrayElements(this,array,elems,mode);
  1612.     }
  1613.     void ReleaseCharArrayElements(jcharArray array, 
  1614.                   jchar *elems,
  1615.                   jint mode) {
  1616.         functions->ReleaseCharArrayElements(this,array,elems,mode);
  1617.     }
  1618.     void ReleaseShortArrayElements(jshortArray array, 
  1619.                    jshort *elems,
  1620.                    jint mode) {
  1621.         functions->ReleaseShortArrayElements(this,array,elems,mode);
  1622.     }
  1623.     void ReleaseIntArrayElements(jintArray array, 
  1624.                  jint *elems,
  1625.                  jint mode) {
  1626.         functions->ReleaseIntArrayElements(this,array,elems,mode);
  1627.     }
  1628.     void ReleaseLongArrayElements(jlongArray array, 
  1629.                   jlong *elems,
  1630.                   jint mode) {
  1631.         functions->ReleaseLongArrayElements(this,array,elems,mode);
  1632.     }
  1633.     void ReleaseFloatArrayElements(jfloatArray array, 
  1634.                    jfloat *elems,
  1635.                    jint mode) {
  1636.         functions->ReleaseFloatArrayElements(this,array,elems,mode);
  1637.     }
  1638.     void ReleaseDoubleArrayElements(jdoubleArray array, 
  1639.                     jdouble *elems,
  1640.                     jint mode) {
  1641.         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
  1642.     }
  1643.  
  1644.     void GetBooleanArrayRegion(jbooleanArray array, 
  1645.                    jsize start, jsize len, jboolean *buf) {
  1646.         functions->GetBooleanArrayRegion(this,array,start,len,buf);
  1647.     }
  1648.     void GetByteArrayRegion(jbyteArray array, 
  1649.                 jsize start, jsize len, jbyte *buf) {
  1650.         functions->GetByteArrayRegion(this,array,start,len,buf);
  1651.     }
  1652.     void GetCharArrayRegion(jcharArray array, 
  1653.                 jsize start, jsize len, jchar *buf) {
  1654.         functions->GetCharArrayRegion(this,array,start,len,buf);
  1655.     }
  1656.     void GetShortArrayRegion(jshortArray array, 
  1657.                  jsize start, jsize len, jshort *buf) {
  1658.         functions->GetShortArrayRegion(this,array,start,len,buf);
  1659.     }
  1660.     void GetIntArrayRegion(jintArray array, 
  1661.                jsize start, jsize len, jint *buf) {
  1662.         functions->GetIntArrayRegion(this,array,start,len,buf);
  1663.     }
  1664.     void GetLongArrayRegion(jlongArray array, 
  1665.                 jsize start, jsize len, jlong *buf) {
  1666.         functions->GetLongArrayRegion(this,array,start,len,buf);
  1667.     }
  1668.     void GetFloatArrayRegion(jfloatArray array, 
  1669.                  jsize start, jsize len, jfloat *buf) {
  1670.         functions->GetFloatArrayRegion(this,array,start,len,buf);
  1671.     }
  1672.     void GetDoubleArrayRegion(jdoubleArray array, 
  1673.                   jsize start, jsize len, jdouble *buf) {
  1674.         functions->GetDoubleArrayRegion(this,array,start,len,buf);
  1675.     }
  1676.  
  1677.     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, 
  1678.                    jboolean *buf) {
  1679.         functions->SetBooleanArrayRegion(this,array,start,len,buf);
  1680.     }
  1681.     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
  1682.                 jbyte *buf) {
  1683.         functions->SetByteArrayRegion(this,array,start,len,buf);
  1684.     }
  1685.     void SetCharArrayRegion(jcharArray array, jsize start, jsize len, 
  1686.                 jchar *buf) {
  1687.         functions->SetCharArrayRegion(this,array,start,len,buf);
  1688.     }
  1689.     void SetShortArrayRegion(jshortArray array, jsize start, jsize len, 
  1690.                  jshort *buf) {
  1691.         functions->SetShortArrayRegion(this,array,start,len,buf);
  1692.     }
  1693.     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
  1694.                jint *buf) {
  1695.         functions->SetIntArrayRegion(this,array,start,len,buf);
  1696.     }
  1697.     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
  1698.                 jlong *buf) {
  1699.         functions->SetLongArrayRegion(this,array,start,len,buf);
  1700.     }
  1701.     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, 
  1702.                  jfloat *buf) {
  1703.         functions->SetFloatArrayRegion(this,array,start,len,buf);
  1704.     }
  1705.     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
  1706.                   jdouble *buf) {
  1707.         functions->SetDoubleArrayRegion(this,array,start,len,buf);
  1708.     }
  1709.  
  1710.     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
  1711.              jint nMethods) {
  1712.         return functions->RegisterNatives(this,clazz,methods,nMethods);
  1713.     }
  1714.     jint UnregisterNatives(jclass clazz) {
  1715.         return functions->UnregisterNatives(this,clazz);
  1716.     }  
  1717.    
  1718.     jint MonitorEnter(jobject obj) {
  1719.         return functions->MonitorEnter(this,obj);
  1720.     }
  1721.     jint MonitorExit(jobject obj) {
  1722.         return functions->MonitorExit(this,obj);
  1723.     }
  1724.  
  1725.     jint GetJavaVM(JavaVM **vm) {
  1726.         return functions->GetJavaVM(this,vm);
  1727.     }
  1728.   
  1729. #endif /* __cplusplus */
  1730. };
  1731.  
  1732. /* These structures will be VM-specific. */
  1733.  
  1734. typedef struct JDK1_1InitArgs {
  1735.     jint version;
  1736.  
  1737.     char **properties;
  1738.     jint checkSource; 
  1739.     jint nativeStackSize;
  1740.     jint javaStackSize;
  1741.     jint minHeapSize;
  1742.     jint maxHeapSize;
  1743.     jint verifyMode;
  1744.     char *classpath;
  1745.  
  1746.     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
  1747.     void (JNICALL *exit)(jint code);
  1748.     void (JNICALL *abort)();
  1749.     
  1750.     jint enableClassGC;
  1751.     jint enableVerboseGC;
  1752.     jint disableAsyncGC;
  1753.     jint verbose;
  1754.     jboolean debugging;
  1755.     jint debugPort;
  1756. } JDK1_1InitArgs;
  1757.  
  1758. typedef struct JDK1_1AttachArgs {
  1759.     void * __padding; /* C compilers don't allow empty structures. */
  1760. } JDK1_1AttachArgs;
  1761.  
  1762. /* End VM-specific. */
  1763.  
  1764. struct JNIInvokeInterface_ {
  1765.     void *reserved0;
  1766.     void *reserved1;
  1767.     void *reserved2;
  1768.  
  1769.     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
  1770.  
  1771.     jint (JNICALL *AttachCurrentThread)
  1772.       (JavaVM *vm, JNIEnv **penv, void *args);
  1773.  
  1774.     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
  1775. };
  1776.  
  1777. struct JavaVM_ {
  1778.     const struct JNIInvokeInterface_ *functions;
  1779.     void *reserved0;
  1780.     void *reserved1;
  1781.     void *reserved2;
  1782. #ifdef __cplusplus
  1783.  
  1784.     jint DestroyJavaVM() {
  1785.         return functions->DestroyJavaVM(this);
  1786.     }
  1787.     jint AttachCurrentThread(JNIEnv **penv, void *args) {
  1788.         return functions->AttachCurrentThread(this, penv, args);
  1789.     }
  1790.     jint DetachCurrentThread() {
  1791.         return functions->DetachCurrentThread(this);
  1792.     }
  1793.  
  1794. #endif
  1795. };
  1796.  
  1797. JNI_PUBLIC_API(void) JNI_GetDefaultJavaVMInitArgs(void *);
  1798.  
  1799. JNI_PUBLIC_API(jint) JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *);
  1800.  
  1801. JNI_PUBLIC_API(jint) JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
  1802. JNI_PUBLIC_API(jref) JNI_MakeLocalRef(JNIEnv *pJNIEnv, void *pHObject);
  1803.  
  1804. #ifdef __cplusplus
  1805. } /* extern "C" */
  1806. #endif /* __cplusplus */
  1807.  
  1808. #endif /* JNI_H */
  1809.  
  1810.  
  1811.